package com.vitabuybuy.tv.utils

import android.text.TextUtils
import java.io.File
import java.io.FileInputStream

import java.text.DecimalFormat
import java.text.NumberFormat
import java.util.regex.Pattern

/**
 * @Description: 字符类型转换工具
 */
object StringUtil {

    const val REGEX_ID_CARD = "(^\\d{18}$)|(^\\d{15}$)"


    // 定义script的正则表达式：<[\\s]*?script[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?script[\\s]*?>
    private val htmlScriptPattern = Pattern.compile(
        "<script[^>]*?>[\\s\\S]*?<\\/script>",
        Pattern.CASE_INSENSITIVE
    )

    // 定义style的正则表达式: <[\\s]*?style[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?style[\\s]*?>
    private val htmlStylePattern = Pattern.compile(
        "<style[^>]*?>[\\s\\S]*?<\\/style>",
        Pattern.CASE_INSENSITIVE
    )

    // 定义HTML标签的正则表达式
    private val htmlTagPattern = Pattern.compile("<[^>]+>", Pattern.CASE_INSENSITIVE)

    // 定义HTML中的转义字符,一些特殊字符处理，主要是&开头;结尾
    private val htmlSpecialCharPattern = Pattern.compile("&[a-z]+;", Pattern.CASE_INSENSITIVE)

    fun toInt(obj: Any?): Int {
        return if (obj == null || "" == obj || "null" == obj) {
            -1
        } else {
            Integer.parseInt(obj.toString())
        }
    }

    fun toFloat(obj: Any?): Float {
        return if (obj == null || "" == obj) {
            0f
        } else {
            java.lang.Float.parseFloat(obj.toString())
        }
    }

    fun toDouble(obj: Any?): Double {
        return if (obj == null || "" == obj) {
            0.0
        } else {
            java.lang.Double.parseDouble(obj.toString())
        }
    }

    /**
     * 将对象转换成Long型空对象默认装换成0
     *
     * @param obj
     * @return
     */
    fun toLong(obj: Any?): Long {
        return if (obj == null || "" == obj) {
            0L
        } else {
            java.lang.Long.parseLong(obj.toString())
        }
    }

    /**
     * 将对象转换成boolean类型,默认为false
     *
     * @param obj
     * @return
     */
    fun toBoolean(obj: Any?): Boolean {
        return if (obj == null || "" == obj) {
            false
        } else java.lang.Boolean.valueOf(obj.toString())
    }


    fun formatDecimal(pattern: String, number: Int): String {
        var number = number
        val myformat = DecimalFormat()
        myformat.applyPattern(pattern)
        if ((number.toString() + "").length > pattern.length) {
            val newNumber = (number.toString() + "").substring(0, pattern.length - 1)
            number = Integer.parseInt(newNumber)
        }
        return myformat.format(number.toLong())
    }

    /**
     * @param @param  number
     * @param @return 设定文件
     * @return String 返回类型
     * @throws
     * @Title: topercent
     * @Description: 将double类型的数据改为百分数，默认显示两位小数
     */
    fun toPercent(number: Double): String {
        val percentFormat = NumberFormat.getPercentInstance()
        percentFormat.minimumFractionDigits = 2
        return percentFormat.format(number)
    }

    fun isMobile(mobile: String): Boolean {
        return (isMatchLength(mobile, 11) && isMobileNO(mobile))
    }

    fun isEmail(strEmail: String): Boolean {
        val strPattern =
            "^[a-zA-Z0-9][\\w\\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\\w\\.-]*[a-zA-Z0-9]\\.[a-zA-Z][a-zA-Z\\.]*[a-zA-Z]$"
        return if (TextUtils.isEmpty(strPattern)) {
            false
        } else {
            strEmail.matches(strPattern.toRegex())
        }
    }

    /**
     * 判断一个字符串的位数
     *
     * @param str
     * @param length
     * @return
     */

    fun isMatchLength(str: String, length: Int): Boolean {
        return if (str.isEmpty()) {
            false
        } else {
            str.length == length
        }
    }


    /**
     * 验证手机格式
     */

    fun isMobileNO(mobileNums: String): Boolean {
        /*
         * 移动：134、135、136、137、138、139、150、151、157(TD)、158、159、187、188
         * 联通：130、131、132、152、155、156、185、186 电信：133、153、180、189、（1349卫通）
         * 总结起来就是第一位必定为1，第二位必定为3或5或8，其他位置的可以为0-9
         */
        val telRegex =
            "[1][34578]\\d{9}"// "[1]"代表第1位为数字1，"[358]"代表第二位可以为3、5、8中的一个，"\\d{9}"代表后面是可以是0～9的数字，有9位。
        return if (TextUtils.isEmpty(mobileNums))
            false
        else
            mobileNums.matches(telRegex.toRegex())

    }

    fun isPasswLength(str: String): Boolean {
        return str.length in 6..15
    }

    /**
     * 判断是否是字母+数字
     *
     * @param number
     * @return
     */
    fun isDigitalAndAlphabet(number: String): Boolean {
        val p1 = Pattern.compile("[0-9]*$")
        val p2 = Pattern.compile("^[A-Za-z]+$")
        return !(p1.matcher(number).matches() || p2.matcher(number).matches())
    }

    /**
     * @param @param  phone
     * @param @return 设定文件
     * @return String 返回类型
     * @throws
     * @Title: phone2Unknown
     * @Description: 将手机号中间4位变为****
     */
    fun phone2Unknown(phone: String): String {
        return phone.substring(0, 3) + "****" + phone.substring(phone.length - 4, phone.length)
    }

    /**
     * 将数据的后len位置為****
     *
     * @param data
     * @param len
     * @return
     */
    fun parseToLastUnknown(data: String, len: Int): String {
        val count = data.length
        val sb = StringBuffer()
        if (count > len) {
            for (i in 0 until len) {
                sb.append("*")
            }
            return data.substring(0, count - len) + sb.toString()
        } else {
            return data
        }

    }

    /**
     * 保留前len位
     *
     * @param data
     * @param len
     * @return
     */
    fun remainFirstWords(data: String, len: Int): String {
        val count = data.length
        val sb = StringBuffer()
        for (i in 0 until len) {
            sb.append("*")
        }
        return if (count < len) {
            data
        } else {
            data.substring(0, count - len) + sb.toString()
        }
    }

    /**
     * @param @param  data
     * @param @return 设定文件
     * @return String 返回类型
     * @throws
     * @Title: to2Decimal
     * @Description: 保留两位小数
     */
    fun to2Decimal(data: Double): String {
        val df = DecimalFormat()
        val style = "#,##0.00"// 定义要显示的数字的格式
        df.applyPattern(style)
        return df.format(data)
    }

    /**
     * @param @param  data
     * @param @return 设定文件
     * @return double 返回类型
     * @throws
     * @Title: to2Double
     * @Description: 四舍五入，保留两位小数，返回double
     */

    fun to2Double(data: Double): Double {
        val df = DecimalFormat()
        val style = "#0.00"// 定义要显示的数字的格式
        df.applyPattern(style)
        return toDouble(df.format(data))

    }

    /**
     * 校验身份证
     *
     * @param idCard
     * @return 校验通过返回true，否则返回false
     */
    fun isIDCard(idCard: String): Boolean {
        return Pattern.matches(REGEX_ID_CARD, idCard)
    }

    /**
     * 对文本中的HTML标签和转义字符进行过滤，替换成指定的字符串
     *
     * @param htmlStr
     * @param replaceStr
     * @return
     */
    fun html2Text(htmlStr: String, replaceStr: String): String {
        var textStr = ""
        try {
            var matcher = htmlScriptPattern.matcher(htmlStr)
            textStr = matcher.replaceAll(replaceStr) // 过滤script标签

            matcher = htmlStylePattern.matcher(textStr)
            textStr = matcher.replaceAll(replaceStr) // 过滤style标签

            matcher = htmlTagPattern.matcher(textStr)
            textStr = matcher.replaceAll(replaceStr) // 过滤html标签

            matcher = htmlSpecialCharPattern.matcher(textStr)
            textStr = matcher.replaceAll(replaceStr) // 过滤特殊字符标签
        } catch (e: Exception) {
            e.printStackTrace()
        }

        return textStr
    }

    /**
     * 获取文件大小
     */
    fun getFileSize(file: File): Long {
        var size: Long = 0
        if (file.exists()) {
            var fis = FileInputStream(file)
            size = fis.available().toLong()
        } else {
            file.createNewFile()
        }
        return size
    }

    /**
     * 格式化文件大小
     */
    fun formetFileSize(fileS: Long): String {
        var df = DecimalFormat("#.00")
        var fileSizeString: String
        var wrongSize = "0KB"
        if (fileS == 0L) {
            return wrongSize
        }
        fileSizeString = when {
            fileS < 1024 -> df.format(fileS) + "B"
            fileS < 1048576 -> df.format(fileS.toDouble() / 1024) + "KB"
            fileS < 1073741824 -> df.format(fileS.toDouble() / 1048576) + "MB"
            else -> df.format(fileS.toDouble() / 1073741824) + "GB"
        }
        return fileSizeString
    }

    /**
     * 隐藏身份证 4304*****7733
     *
     * @param idCard 身份证
     * @return
     */
    fun hideIdCard(idCard: String): String {
        return hide(idCard, 4, 4)
    }

    /**
     * 隐藏字符串
     *
     * @param str            字符串
     * @param beforePosition 隐藏开始位置
     * @param afterPosition  隐藏结束位置
     * @return
     */
    fun hide(str: String, beforePosition: Int, afterPosition: Int): String {
        if (TextUtils.isEmpty(str)) {
            return str
        }
        val length = str.length
        //替换字符串，当前使用“*”
        val replaceSymbol = "*"
        val sb = StringBuilder()
        for (i in 0 until length) {
            if (i < beforePosition || i >= length - afterPosition) {
                sb.append(str[i])
            } else {
                sb.append(replaceSymbol)
            }
        }
        return sb.toString()
    }

    /**
     * 中国电信号码格式验证 手机段： 133,153,180,181,189,177,1700,173,191,199
     */
    private val CHINA_TELECOM_PATTERN =
        "(?:^(?:\\+86)?1(?:33|53|7[37]|8[019]|9[19])\\d{8}$)|(?:^(?:\\+86)?1700\\d{7}$)"

    /**
     * 中国联通号码格式验证 手机段：130,131,132,155,156,185,186,145,176,1707,1708,1709,175,166
     */
    private val CHINA_UNICOM_PATTERN =
        "(?:^(?:\\+86)?1(?:3[0-2]|4[5]|5[56]|66|7[56]|8[56])\\d{8}$)|(?:^(?:\\+86)?170[7-9]\\d{7}$)"

    /**
     * 中国移动号码格式验证
     * 手机段：134,135,136,137,138,139,150,151,152,157,158,159,182,183,184
     * ,187,188,147,178,1705,189,198
     *
     */
    private val CHINA_MOBILE_PATTERN =
        "(?:^(?:\\+86)?1(?:3[4-9]|4[7]|5[0-27-9]|7[8]|8[2-4789]|98)\\d{8}$)|(?:^(?:\\+86)?1705\\d{7}$)"

    private fun match(regex: String, input: String): Boolean {
        return Pattern.matches(regex, input)
    }

    fun checkMobile(telphone: String): String {
        return when {
            match(CHINA_MOBILE_PATTERN, telphone) -> "中国移动"
            match(CHINA_UNICOM_PATTERN, telphone) -> "中国联通"
            match(CHINA_TELECOM_PATTERN, telphone) -> "中国电信"
            else -> "其他运营商"
        }
    }

    fun judgePassword(pwd: String): Boolean {
        return Pattern.compile("^[a-zA-Z0-9_]{6,16}+$").matcher(pwd).matches()
    }

    fun replaceEndChar(input: String): String {
        return Pattern.compile("\\,*$").matcher(input).replaceAll("")
    }

}
